﻿// Decompiled with JetBrains decompiler
// Type: DnProcessSimulateCommands.InterferenceVolume.CUiIVInterferenceVolumeForm
// Assembly: DnProcessSimulateCommands, Version=2402.0.0.890, Culture=neutral, PublicKeyToken=null
// MVID: A885D881-AEDF-447E-852A-6F13102E089C
// Assembly location: C:\Program Files\Tecnomatix_2402\eMPower\DotNetCommands\DnProcessSimulateCommands.dll

using DnProcessSimulateCommands.InterferenceVolume.Res;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Windows.Forms;
using Tecnomatix.Engineering;
using Tecnomatix.Engineering.PrivateImplementationDetails;
using Tecnomatix.Engineering.Ui;


namespace DnProcessSimulateCommands.InterferenceVolume;

public class CUiIVInterferenceVolumeForm : TxForm, IUiIVInterferenceVolumeDataProvider
{
  private CUiIVInterferenceVolumeForm.eModes m_activeModes;
  private bool m_suppressUiEnablers;
  private bool m_interferenceVolumeNameAutoGenerating;
  private bool m_interferenceVolumeNameShouldAutogenerate = true;
  private CApIVInterferenceVolumeCreator m_ivCreator;
  private TxInterferenceVolume_MayProceedCalculation m_mayProceedCallback;
  private CUiIVNotificationFeedbackEventHandler m_creatorNotificationFeedback;
  private CUiIVNotificationMgr m_notificationMgr;
  private bool m_ignoreUiEvents;
  private IContainer components;
  private TxProgressBar m_progressBar;
  private TxObjEditBoxCtrl m_sv2EditBox;
  private TxObjEditBoxCtrl m_sv1EditBox;
  private TextBox m_nameTextBox;
  private Label m_sv2Label;
  private Label m_sv1Label;
  private Label m_nameLabel;
  private Button m_closeButton;
  private Button m_createButton;

  public CUiIVInterferenceVolumeForm()
  {
    this.InitializeComponent();
    this.m_notificationMgr = new CUiIVNotificationMgr();
    // ISSUE: method pointer
    this.m_mayProceedCallback = new TxInterferenceVolume_MayProceedCalculation((object) this, __methodptr(CreateInterferenceVolume_MayProceed));
    this.m_creatorNotificationFeedback = new CUiIVNotificationFeedbackEventHandler(this.CreateInterferenceVolume_NotificationFeedback);
    this.m_ivCreator = new CApIVInterferenceVolumeCreator((IUiIVInterferenceVolumeDataProvider) this);
    this.m_ivCreator.NotificationFeedback = this.m_creatorNotificationFeedback;
    this.InitControlsProperties();
    this.RegisterControlsEvents();
    this.RegisterAppEvents();
  }

  public void Show(CUiIVInterferenceVolumeInitParams initParams)
  {
    this.InitControlsValues(initParams);
    ((Control) this).Show();
    this.SetInitialFocus();
  }

  private void InitControlsProperties()
  {
    CApIVSweptVolumeValidator sweptVolumeValidator = new CApIVSweptVolumeValidator();
    TxPickProvider[] txPickProviderArray = new TxPickProvider[3]
    {
      null,
      (TxPickProvider) 1,
      (TxPickProvider) 2
    };
    this.m_sv1EditBox.SetValidator((ITxValidator) sweptVolumeValidator);
    this.m_sv1EditBox.SetPickProviders(txPickProviderArray);
    this.m_sv1EditBox.ListenToPick = true;
    this.m_sv2EditBox.SetValidator((ITxValidator) sweptVolumeValidator);
    this.m_sv2EditBox.SetPickProviders(txPickProviderArray);
    this.m_sv2EditBox.ListenToPick = true;
  }

  private void InitControlsValues(CUiIVInterferenceVolumeInitParams initParams)
  {
    this.SuppressUiEnablers = true;
    this.SweptVolumes_Init(initParams.SweptVolumes);
    this.InterferenceVolumeName_Init();
    this.SuppressUiEnablers = false;
  }

  private void RegisterControlsEvents()
  {
    this.m_sv1EditBox.Picked += new TxObjEditBoxCtrl_PickedEventHandler(this.m_sv1EditBox_Picked);
    this.m_sv1EditBox.TypeValid += new EventHandler(this.m_sv1EditBox_TypeValid);
    this.m_sv1EditBox.TypeInvalid += new EventHandler(this.m_sv1EditBox_TypeInvalid);
    this.m_sv2EditBox.Picked += new TxObjEditBoxCtrl_PickedEventHandler(this.m_sv2EditBox_Picked);
    this.m_sv2EditBox.TypeValid += new EventHandler(this.m_sv2EditBox_TypeValid);
    this.m_sv2EditBox.TypeInvalid += new EventHandler(this.m_sv2EditBox_TypeInvalid);
    this.m_nameTextBox.TextChanged += new EventHandler(this.m_nameTextBox_TextChanged);
    this.m_createButton.Click += new EventHandler(this.m_createStopButton_Click);
    this.m_closeButton.Click += new EventHandler(this.m_closeButton_Click);
    ((Form) this).FormClosed += new FormClosedEventHandler(this.CUiIVInterferenceVolumeForm_FormClosed);
    ((Form) this).FormClosing += new FormClosingEventHandler(this.CUiIVInterferenceVolumeForm_FormClosing);
  }

  private void RegisterAppEvents()
  {
    this.m_ivCreator.CreateStarted += new CApIVInterferenceVolumeCreator.CreateStartedEventHandler(this.OnCreateStarted);
    this.m_ivCreator.CreateFinished += new CApIVInterferenceVolumeCreator.CreateFinishedEventHandler(this.OnCreateFinished);
  }

  private void UnRegisterAppEvents()
  {
    this.m_ivCreator.CreateStarted -= new CApIVInterferenceVolumeCreator.CreateStartedEventHandler(this.OnCreateStarted);
    this.m_ivCreator.CreateFinished -= new CApIVInterferenceVolumeCreator.CreateFinishedEventHandler(this.OnCreateFinished);
  }

  private void SetInitialFocus()
  {
    if (TxSweptVolume.op_Inequality(this.FirstSweptVolume, (ITxObject) null) && TxSweptVolume.op_Equality(this.SecondSweptVolume, (ITxObject) null))
      this.m_sv2EditBox.Focus();
    else
      this.m_sv1EditBox.Focus();
  }

  private void SweptVolumes_Init(TxObjectList sweptVolumes)
  {
    TxSweptVolume txSweptVolume1 = (TxSweptVolume) null;
    TxSweptVolume txSweptVolume2 = (TxSweptVolume) null;
    if (sweptVolumes != null && ((Collection<ITxObject>) sweptVolumes).Count > 0)
    {
      txSweptVolume1 = ((Collection<ITxObject>) sweptVolumes)[0] as TxSweptVolume;
      if (((Collection<ITxObject>) sweptVolumes).Count > 1)
        txSweptVolume2 = ((Collection<ITxObject>) sweptVolumes)[1] as TxSweptVolume;
    }
    this.FirstSweptVolume = txSweptVolume1;
    this.SecondSweptVolume = txSweptVolume2;
  }

  private void InterferenceVolumeName_Init()
  {
    if (!this.m_interferenceVolumeNameShouldAutogenerate)
      return;
    this.InterferenceVolumeName = this.GenerateInterferenceVolumeName(this.FirstSweptVolume, this.SecondSweptVolume);
  }

  private string GenerateInterferenceVolumeName(TxSweptVolume firstSV, TxSweptVolume secondSV)
  {
    string volumeDisplayName = CUiIVInterferenceVolumeResourceTable.DEFAULT_INTERFERENCE_VOLUME_DISPLAY_NAME;
    bool flag = true;
    string interferenceVolumeName;
    if (TxSweptVolume.op_Inequality(firstSV, (ITxObject) null) && TxSweptVolume.op_Inequality(secondSV, (ITxObject) null))
    {
      TxInterferenceVolume interferenceVolume = (TxInterferenceVolume) null;
      if (TxSweptVolume.op_Inequality(firstSV, (ITxObject) secondSV))
      {
        TxObjectList sweptVolumes = new TxObjectList();
        ((Collection<ITxObject>) sweptVolumes).Add((ITxObject) firstSV);
        ((Collection<ITxObject>) sweptVolumes).Add((ITxObject) secondSV);
        interferenceVolume = CApIVUtilities.GetExistingInterferenceVolume(sweptVolumes);
      }
      if (TxInterferenceVolume.op_Equality(interferenceVolume, (ITxObject) null))
      {
        interferenceVolumeName = $"{firstSV.HoldingObject.Name}_{secondSV.HoldingObject.Name}_{volumeDisplayName}";
      }
      else
      {
        interferenceVolumeName = interferenceVolume.Name;
        flag = false;
      }
    }
    else
      interferenceVolumeName = volumeDisplayName;
    if (flag)
      interferenceVolumeName = TxApplication.ActiveDocument.PhysicalRoot.GetUniqueDisplayName(interferenceVolumeName);
    return interferenceVolumeName;
  }

  private bool SuppressUiEnablers
  {
    get => this.m_suppressUiEnablers;
    set
    {
      if (this.m_suppressUiEnablers == value)
        return;
      this.m_suppressUiEnablers = value;
      if (this.m_suppressUiEnablers)
        return;
      this.UpdateUiEnablers();
    }
  }

  private TxSweptVolume FirstSweptVolume
  {
    get
    {
      try
      {
        return this.m_sv1EditBox.Object as TxSweptVolume;
      }
      catch (Exception ex)
      {
        return (TxSweptVolume) null;
      }
    }
    set
    {
      try
      {
        this.m_sv1EditBox.Object = (ITxObject) value;
      }
      catch (Exception ex)
      {
      }
    }
  }

  private TxSweptVolume SecondSweptVolume
  {
    get
    {
      try
      {
        return this.m_sv2EditBox.Object as TxSweptVolume;
      }
      catch (Exception ex)
      {
        return (TxSweptVolume) null;
      }
    }
    set
    {
      try
      {
        this.m_sv2EditBox.Object = (ITxObject) value;
      }
      catch (Exception ex)
      {
      }
    }
  }

  private string InterferenceVolumeName
  {
    get => this.m_nameTextBox.Text;
    set
    {
      this.m_interferenceVolumeNameAutoGenerating = true;
      this.m_nameTextBox.Text = value;
      this.m_interferenceVolumeNameAutoGenerating = false;
      this.OnInterferenceVolumeName_Modified();
    }
  }

  internal bool EnterMode(CUiIVInterferenceVolumeForm.eModes mode)
  {
    bool flag = false;
    if (this.ContainsMode(mode, CUiIVInterferenceVolumeForm.eModes.Create) && !this.IsInMode(mode))
      flag = this.EnterCreationMode();
    return flag;
  }

  internal bool CanEnterMode(CUiIVInterferenceVolumeForm.eModes mode)
  {
    bool flag = false;
    if (this.ContainsMode(mode, CUiIVInterferenceVolumeForm.eModes.Create))
      flag = true;
    return flag;
  }

  internal bool ExitMode(CUiIVInterferenceVolumeForm.eModes mode)
  {
    bool flag = false;
    if (this.ContainsMode(mode, CUiIVInterferenceVolumeForm.eModes.Create) && this.IsInMode(CUiIVInterferenceVolumeForm.eModes.Create))
      flag = this.ExitCreationMode();
    return flag;
  }

  internal bool CanExitMode(CUiIVInterferenceVolumeForm.eModes mode)
  {
    bool flag = false;
    if (this.ContainsMode(mode, CUiIVInterferenceVolumeForm.eModes.Create) && this.IsInMode(CUiIVInterferenceVolumeForm.eModes.Create))
      flag = !this.m_ivCreator.IsCreationRunning;
    return flag;
  }

  internal bool IsInMode(CUiIVInterferenceVolumeForm.eModes mode)
  {
    return this.ContainsMode(this.m_activeModes, mode);
  }

  private bool ContainsMode(
    CUiIVInterferenceVolumeForm.eModes candidate,
    CUiIVInterferenceVolumeForm.eModes mode)
  {
    bool flag = false;
    if (mode == CUiIVInterferenceVolumeForm.eModes.None && candidate == CUiIVInterferenceVolumeForm.eModes.None || (candidate & mode) == mode)
      flag = true;
    return flag;
  }

  private void MarkAsActive(CUiIVInterferenceVolumeForm.eModes mode) => this.m_activeModes |= mode;

  private void MarkAsInactive(CUiIVInterferenceVolumeForm.eModes mode)
  {
    this.m_activeModes &= ~mode;
  }

  private bool EnterCreationMode()
  {
    bool flag = false;
    if (this.CanEnterMode(CUiIVInterferenceVolumeForm.eModes.Create))
    {
      this.SuppressUiEnablers = true;
      this.m_sv1EditBox.ReadOnly = true;
      this.m_sv1EditBox.Enabled = false;
      this.m_sv2EditBox.ReadOnly = true;
      this.m_sv2EditBox.Enabled = false;
      this.m_nameTextBox.ReadOnly = true;
      this.m_nameTextBox.Enabled = false;
      ((ProgressBar) this.m_progressBar).Value = ((ProgressBar) this.m_progressBar).Minimum;
      this.m_createButton.Text = CUiIVInterferenceVolumeResourceTable.TEXT_BTN_STOP;
      this.m_closeButton.Enabled = false;
      this.m_ivCreator.CallBack = this.m_mayProceedCallback;
      this.MarkAsActive(CUiIVInterferenceVolumeForm.eModes.Create);
      ((Control) this).Refresh();
      flag = true;
    }
    return flag;
  }

  private bool ExitCreationMode()
  {
    bool flag = false;
    if (this.CanExitMode(CUiIVInterferenceVolumeForm.eModes.Create))
    {
      this.m_ignoreUiEvents = true;
      this.m_sv1EditBox.ReadOnly = false;
      this.m_sv1EditBox.Enabled = true;
      this.m_sv2EditBox.ReadOnly = false;
      this.m_sv2EditBox.Enabled = true;
      this.m_nameTextBox.ReadOnly = false;
      this.m_nameTextBox.Enabled = true;
      ((ProgressBar) this.m_progressBar).Value = ((ProgressBar) this.m_progressBar).Minimum;
      this.m_createButton.Text = CUiIVInterferenceVolumeResourceTable.TEXT_BTN_CREATE;
      this.m_closeButton.Enabled = true;
      this.SuppressUiEnablers = false;
      this.m_interferenceVolumeNameShouldAutogenerate = true;
      this.MarkAsInactive(CUiIVInterferenceVolumeForm.eModes.Create);
      TxApplication.RefreshDisplay();
      Application.DoEvents();
      this.m_ignoreUiEvents = false;
      flag = true;
    }
    return flag;
  }

  private void UpdateUiEnablers()
  {
    if (this.SuppressUiEnablers)
      return;
    this.UpdateCreateButtonEnabler();
  }

  private void UpdateCreateButtonEnabler()
  {
    if (this.SuppressUiEnablers)
      return;
    bool flag = false;
    if (this.m_ivCreator.SweptVolumes_AreInitialized() && this.m_ivCreator.InterferenceVolumeName_IsValid())
      flag = true;
    this.m_createButton.Enabled = flag;
  }

  private void m_sv1EditBox_Picked(object sender, TxObjEditBoxCtrl_PickedEventArgs e)
  {
    this.OnFirstSweptVolume_Modified();
    if (!TxSweptVolume.op_Inequality(this.FirstSweptVolume, (ITxObject) null) || !TxSweptVolume.op_Equality(this.SecondSweptVolume, (ITxObject) null))
      return;
    this.m_sv2EditBox.Focus();
  }

  private void m_sv1EditBox_TypeValid(object sender, EventArgs e)
  {
    this.OnFirstSweptVolume_Modified();
  }

  private void m_sv1EditBox_TypeInvalid(object sender, EventArgs e)
  {
    this.OnFirstSweptVolume_Modified();
  }

  private void m_sv2EditBox_Picked(object sender, TxObjEditBoxCtrl_PickedEventArgs e)
  {
    this.OnSecondSweptVolume_Modified();
    if (!TxSweptVolume.op_Inequality(this.SecondSweptVolume, (ITxObject) null) || !TxSweptVolume.op_Equality(this.FirstSweptVolume, (ITxObject) null))
      return;
    this.m_sv1EditBox.Focus();
  }

  private void m_sv2EditBox_TypeValid(object sender, EventArgs e)
  {
    this.OnSecondSweptVolume_Modified();
  }

  private void m_sv2EditBox_TypeInvalid(object sender, EventArgs e)
  {
    this.OnSecondSweptVolume_Modified();
  }

  private void m_nameTextBox_TextChanged(object sender, EventArgs e)
  {
    if (!this.m_interferenceVolumeNameAutoGenerating)
      this.m_interferenceVolumeNameShouldAutogenerate = this.InterferenceVolumeName == "";
    this.OnInterferenceVolumeName_Modified();
  }

  private void m_createStopButton_Click(object sender, EventArgs e)
  {
    if (this.m_ignoreUiEvents)
      return;
    if (this.IsInMode(CUiIVInterferenceVolumeForm.eModes.Create))
      this.m_ivCreator.AbortCreation();
    else
      this.m_ivCreator.Create();
  }

  private void m_closeButton_Click(object sender, EventArgs e) => ((Form) this).Close();

  private void CUiIVInterferenceVolumeForm_FormClosed(object sender, EventArgs e)
  {
    this.UnRegisterAppEvents();
  }

  private void CUiIVInterferenceVolumeForm_FormClosing(object sender, FormClosingEventArgs e)
  {
    if (!this.IsInMode(CUiIVInterferenceVolumeForm.eModes.Create))
      return;
    e.Cancel = true;
  }

  private void ProcessUIEvents() => Application.DoEvents();

  private void OnFirstSweptVolume_Modified()
  {
    this.InterferenceVolumeName_Init();
    this.UpdateUiEnablers();
  }

  private void OnSecondSweptVolume_Modified()
  {
    this.InterferenceVolumeName_Init();
    this.UpdateUiEnablers();
  }

  private void OnInterferenceVolumeName_Modified() => this.UpdateUiEnablers();

  private void OnCreateStarted(object sender, EventArgs e)
  {
    this.EnterMode(CUiIVInterferenceVolumeForm.eModes.Create);
  }

  private void OnCreateFinished(object sender, EventArgs e)
  {
    this.ExitMode(CUiIVInterferenceVolumeForm.eModes.Create);
  }

  private bool CreateInterferenceVolume_MayProceed(int progress)
  {
    if (progress >= 0 && progress <= 100 && progress > ((ProgressBar) this.m_progressBar).Value)
      ((ProgressBar) this.m_progressBar).Value = progress;
    this.ProcessUIEvents();
    return !this.m_ivCreator.IsCreationAbortSubmitted;
  }

  private void CreateInterferenceVolume_NotificationFeedback(
    object sender,
    CUiIVNotificationFeedbackEventArgs args)
  {
    bool flag1 = true;
    bool flag2 = true;
    List<DialogResult> dialogResultList = new List<DialogResult>();
    switch (args.Notification.Code)
    {
      case eUiIVNotificationCode.CAN_CREATE_ERR_IDENTICAL_INTERFERENCE_VOLUME_OPERATION_HOLDERS:
      case eUiIVNotificationCode.CAN_CREATE_ERR_IDENTICAL_INTERFERENCE_VOLUME_PROGRAM_HOLDERS:
      case eUiIVNotificationCode.CAN_CREATE_ERR_IDENTICAL_SWEPT_VOLUMES:
      case eUiIVNotificationCode.CREATE_ERR_INTERFERENCE_VOLUME_CREATE_FAIL:
      case eUiIVNotificationCode.CREATE_ERR_INTERFERENCE_VOLUME_CALCULATE_FAIL:
        flag2 = false;
        break;
      case eUiIVNotificationCode.CAN_CREATE_WARNING_INTERFERENCE_VOLUME_ALREADY_EXIST:
      case eUiIVNotificationCode.CAN_CREATE_WARNING_SWEPT_VOLUME_MISSING_GEOMETRY:
      case eUiIVNotificationCode.CAN_CREATE_WARNING_ALL_SWEPT_VOLUMES_MISSING_GEOMETRY:
      case eUiIVNotificationCode.CAN_CREATE_WARNING_BLANKED_SWEPT_VOLUMES:
        dialogResultList.Add(DialogResult.Yes);
        break;
      case eUiIVNotificationCode.CREATE_WARNING_INTERFERENCE_VOLUME_MISSING_INTERSECTION:
        dialogResultList.Add(DialogResult.Yes);
        dialogResultList.Add(DialogResult.No);
        break;
      default:
        flag1 = false;
        flag2 = false;
        break;
    }
    if (!flag1)
      return;
    DialogResult dlgResult = this.m_notificationMgr.Show(args.Notification, CUiIVInterferenceVolumeResourceTable.CMD_INTERFERENCE_VOLUME_NAME);
    if (!flag2)
      return;
    if (!dialogResultList.Contains(dlgResult))
      args.FeedbackResult = CUiIVNotificationFeedbackEventArgs.eFeedbackResult.Abort;
    else
      args.FeedbackResult = args.ConvertToFeedbackResult(dlgResult);
  }

  public TxObjectList IVData_SweptVolumes
  {
    get
    {
      TxObjectList dataSweptVolumes = new TxObjectList(2);
      TxSweptVolume firstSweptVolume = this.FirstSweptVolume;
      TxSweptVolume secondSweptVolume = this.SecondSweptVolume;
      if (TxSweptVolume.op_Inequality(firstSweptVolume, (ITxObject) null))
        ((Collection<ITxObject>) dataSweptVolumes).Add((ITxObject) firstSweptVolume);
      if (TxSweptVolume.op_Inequality(secondSweptVolume, (ITxObject) null))
        ((Collection<ITxObject>) dataSweptVolumes).Add((ITxObject) secondSweptVolume);
      return dataSweptVolumes;
    }
  }

  public string IVData_Name => this.InterferenceVolumeName;

  public TxColor IVData_Color
  {
    get
    {
      TxColor ivDataColor = TxColor.FromBgrColor(TxApplication.Options.Color.InterferenceVolumeColor);
      ivDataColor.Transparency = 1.0;
      return ivDataColor;
    }
  }

  protected virtual void Dispose(bool disposing)
  {
    if (disposing && this.components != null)
      this.components.Dispose();
    base.Dispose(disposing);
  }

  private void InitializeComponent()
  {
    ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (CUiIVInterferenceVolumeForm));
    this.m_sv1Label = new Label();
    this.m_sv1EditBox = new TxObjEditBoxCtrl();
    this.m_sv2Label = new Label();
    this.m_sv2EditBox = new TxObjEditBoxCtrl();
    this.m_nameLabel = new Label();
    this.m_nameTextBox = new TextBox();
    this.m_progressBar = new TxProgressBar();
    this.m_createButton = new Button();
    this.m_closeButton = new Button();
    ((Control) this).SuspendLayout();
    componentResourceManager.ApplyResources((object) this.m_sv1Label, "m_sv1Label");
    this.m_sv1Label.Name = "m_sv1Label";
    componentResourceManager.ApplyResources((object) this.m_sv1EditBox, "m_sv1EditBox");
    this.m_sv1EditBox.KeepFaceEmphasizedWhenControlIsNotFocused = true;
    this.m_sv1EditBox.ListenToPick = false;
    ((Control) this.m_sv1EditBox).Name = "m_sv1EditBox";
    this.m_sv1EditBox.Object = (ITxObject) null;
    this.m_sv1EditBox.PickAndClear = false;
    this.m_sv1EditBox.PickLevel = (TxPickLevel) 6;
    this.m_sv1EditBox.PickOnly = false;
    this.m_sv1EditBox.ReadOnly = false;
    this.m_sv1EditBox.ValidatorType = (TxValidatorType) 3;
    componentResourceManager.ApplyResources((object) this.m_sv2Label, "m_sv2Label");
    this.m_sv2Label.Name = "m_sv2Label";
    componentResourceManager.ApplyResources((object) this.m_sv2EditBox, "m_sv2EditBox");
    this.m_sv2EditBox.KeepFaceEmphasizedWhenControlIsNotFocused = true;
    this.m_sv2EditBox.ListenToPick = false;
    ((Control) this.m_sv2EditBox).Name = "m_sv2EditBox";
    this.m_sv2EditBox.Object = (ITxObject) null;
    this.m_sv2EditBox.PickAndClear = false;
    this.m_sv2EditBox.PickLevel = (TxPickLevel) 6;
    this.m_sv2EditBox.PickOnly = false;
    this.m_sv2EditBox.ReadOnly = false;
    this.m_sv2EditBox.ValidatorType = (TxValidatorType) 3;
    componentResourceManager.ApplyResources((object) this.m_nameLabel, "m_nameLabel");
    this.m_nameLabel.Name = "m_nameLabel";
    componentResourceManager.ApplyResources((object) this.m_nameTextBox, "m_nameTextBox");
    this.m_nameTextBox.Name = "m_nameTextBox";
    componentResourceManager.ApplyResources((object) this.m_progressBar, "m_progressBar");
    ((Control) this.m_progressBar).Name = "m_progressBar";
    ((ProgressBar) this.m_progressBar).Step = 1;
    componentResourceManager.ApplyResources((object) this.m_createButton, "m_createButton");
    this.m_createButton.Name = "m_createButton";
    this.m_createButton.UseVisualStyleBackColor = true;
    componentResourceManager.ApplyResources((object) this.m_closeButton, "m_closeButton");
    this.m_closeButton.Name = "m_closeButton";
    this.m_closeButton.UseVisualStyleBackColor = true;
    ((Form) this).AcceptButton = (IButtonControl) this.m_createButton;
    componentResourceManager.ApplyResources((object) this, "$this");
    ((ContainerControl) this).AutoScaleMode = AutoScaleMode.Font;
    ((Control) this).Controls.Add((Control) this.m_sv1EditBox);
    ((Control) this).Controls.Add((Control) this.m_sv2EditBox);
    ((Control) this).Controls.Add((Control) this.m_nameTextBox);
    ((Control) this).Controls.Add((Control) this.m_progressBar);
    ((Control) this).Controls.Add((Control) this.m_createButton);
    ((Control) this).Controls.Add((Control) this.m_closeButton);
    ((Control) this).Controls.Add((Control) this.m_sv2Label);
    ((Control) this).Controls.Add((Control) this.m_sv1Label);
    ((Control) this).Controls.Add((Control) this.m_nameLabel);
    ((Form) this).MaximizeBox = false;
    ((Form) this).MinimizeBox = false;
    ((Control) this).Name = nameof (CUiIVInterferenceVolumeForm);
    this.ShouldCloseOnDocumentUnloading = true;
    ((Control) this).ResumeLayout(false);
    ((Control) this).PerformLayout();
  }

  [Flags]
  internal enum eModes
  {
    None = 0,
    Create = 1,
  }
}
